Méthode d'Héron

Il s'agit d'un célèbre algorithme, trouvé par les Babyloniens (-1800 environ -532) mais connu sous le nom d'algorithme de Héron, qui permet de calculer des approximations de la racine carrée d'un nombre, de plus en plus précises, et cela avec une grande facilité et surtout une grande rapidité. 

L'idée vient d'une construction géométrique qu'on étudiera dans cette 1^re partie.

PARTIE A  Construction géométrique pour "quarrer" un rectangle
Idée de l'algorithme 
En partant d'un rectangle d'aire égale à `N` , de dimensions `a`  et  `b`  , tels que `N=ab` , la construction permet d'obtenir une suite de rectangles, tous d'aire égale à `N` , mais dont les dimensions tendent vers celles d'un carré, donc de plus en plus proches de la racine carrée de `N` .

1. Le fichier de géométrie dynamique suivant montre la construction envisagée par Héron avec `N=20` . Afin d'observer les étapes de l'algorithme, il suffit de cliquer sur le bouton "double-flèche droite" en bas de l'écran pour la suivre pas à pas.

Étapes de construction

• 1→5 : construction du rectangle initial `\text{OA}_0\text{C}_0\text{B}_0`  d'aire égale à   `N` , et de dimensions arbitraires  `a` et  `b` tels que `ab=\text{N` (ici `a=10` et `b=2` ). On a donc `\text{OA}_0=a`  et `\text{OB}_0=b` .
  
• 6→7 : construction du cercle de centre `\text{A}_0` et de rayon `\text{A}_0\text{C}_0` qui coupe la droite    `\text{OA}_0`   en `\text{D}_0` .
  
• 8→9 : construction de la médiatrice `d_1` du segment `[\text{OD}_0 ]`  coupe `[\text{OA}_0 ]`  en `\text{A}_1` .
  
• 10→12 : construction de la parallèle à la droite `\text{A}_1\text{B}_0` passant par    `\text{A}_0` qui coupe    `(\text{OB}_0)` en `\text{B}_1` .
  
• 13→15 : construction du point   `\text{C}_1` , le 4ème sommet du rectangle  \(\text{OA}_1\text{C}_1\text{B}_1\) . 
  
• 16→25 : Réitération de la construction à partir du rectangle    \(\text{OA}_1\text{C}_1\text{B}_1\)  pour obtenir le rectangle   \(\text{OA}_2\text{C}_2\text{B}_2\) .             
  
• 26→35 : Réitération de la construction à partir du rectangle    \(\text{OA}_2\text{C}_2\text{B}_2\)  pour obtenir le rectangle   \(\text{OA}_3\text{C}_3\text{B}_3\) .            
  

2. À l'aide de la construction montrée dans le fichier de géométrique précédente, répondre aux questions suivante .
a. Exprimer la longueur du segment    `[\text{OD}_0 ]`   en fonction de   `a` et  `b` .
b. Exprimer la longueur du segment      `[\text{OA}_1 ]`    en fonction de   `a` et  `b`   .
c. Démontrer que, quel que soit   `a` et  `b` , l'aire du rectangle    \(\text{OA}_1\text{C}_1\text{B}_1\)   est égale à celle du rectangle   `\text{OA}_0\text{C}_0\text{B}_0`  , donc égale à   `N`   .
d. A chaque étape, les dimensions du rectangle obtenu donnent un encadrement de   `\sqrt(N)`   . Déterminer les deux bornes de l’encadrement de  `\sqrt(20)`  après trois itérations de la construction.

PARTIE B  Modélisation de la suite numérique avec un tableur

On vient de voir que, si on connait deux nombres  `a_0` et  `b_0` tels que `a_0 b_0=N` , alors les nombres `a_1` et `b_1` tels que \(a_1=\dfrac{a_0+b_0}{2}\) et \(b_1=\dfrac{N}{a_1}\)  vérifient bien \(a_1 b_1=N\) , et sont plus proches l'un de l'autre que ne le sont  `a_0` et  `b_0` .
En réitérant, on obtient des couples de nombres, de plus en plus proches l'un de l'autre, et dont le produit reste égal à     `N`   .

1. En suivant le modèle montré dans la figure suivante, générer, avec un tableur, en colonne les termes des suites \((a_n)\) et \((b_n)\) , en prenant comme premiers termes par exemple \(a=10\) et \(b=\dfrac{20}{a}\) (pour chercher à calculer  \(\sqrt{20}\) ).

2. Quel est le rang du terme donnant une approximation de  \(\sqrt{20}\) à \(10^{-5}\) près ? et à  \(10^{-10}\) près ?

3. Changer la valeur de    `a_0` , en prenant soin que  `b_0`  se recalcule automatiquement pour que le produit reste égal à \(20\) . Répondre à la question précédente. Que constate-t-on ?

Vocabulaire
On dit que ces suites convergent vers  \(\sqrt{20}\)  , ou encore qu'elles admettent une limite finie, égale à  \(\sqrt{20}\) .
On écrit : \(\lim\limits_{n \rightarrow +\infty} a_n=\sqrt{20}\) .

PARTIE C  Programmation d'un algorithme

Écrire un programme Python qui demande la valeur de `N` , celle de `a_0` , ainsi que la précision avec laquelle on veut obtenir `\sqrt(N)`  et qui calcule les termes de la suite \((a_n)\) jusqu'à ce que la précision demandée soit atteinte.